ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್ ಪ್ಯಾಟರ್ನ್‌ಗಳು: ವರ್ತನೆಯ ವರ್ಧನೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯ ನಿರಂತರವಾಗಿ ವಿಕಸನಗೊಳ್ಳುತ್ತಿರುವ ಭೂದೃಶ್ಯದಲ್ಲಿ, ಸ್ವಚ್ಛವಾದ, ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವುದು ಅತ್ಯುನ್ನತವಾಗಿದೆ. ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್ ಮಾದರಿಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳ ಮೂಲ ತರ್ಕವನ್ನು ಮಾರ್ಪಡಿಸದೆ ಅವುಗಳ ವರ್ತನೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಪ್ರಬಲ ತಂತ್ರವನ್ನು ನೀಡುತ್ತವೆ. ಈ ವಿಧಾನವು ಕಾಳಜಿಗಳ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ, ಪರೀಕ್ಷಿಸಬಹುದಾದ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.

ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಎಂದರೇನು?

ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್ ಎನ್ನುವುದು ಮಾಡ್ಯೂಲ್ ಅನ್ನು (ಸಾಮಾನ್ಯವಾಗಿ ಫಂಕ್ಷನ್ ಅಥವಾ ವರ್ಗ) ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಆ ಮಾಡ್ಯೂಲ್‌ನ ಮಾರ್ಪಡಿಸಿದ ಆವೃತ್ತಿಯನ್ನು ಹಿಂತಿರುಗಿಸುವ ಕಾರ್ಯವಾಗಿದೆ. ಡೆಕೋರೇಟರ್ ಮೂಲ ಮಾಡ್ಯೂಲ್‌ನ ಮೂಲ ಕೋಡ್ ಅನ್ನು ನೇರವಾಗಿ ಬದಲಾಯಿಸದೆ ಅದರ ನಡವಳಿಕೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ ಅಥವಾ ಮಾರ್ಪಡಿಸುತ್ತದೆ. ಇದು ಓಪನ್/ಕ್ಲೋಸ್ಡ್ ತತ್ವಕ್ಕೆ ಬದ್ಧವಾಗಿದೆ, ಇದು ಸಾಫ್ಟ್‌ವೇರ್ ಘಟಕಗಳು (ವರ್ಗಗಳು, ಮಾಡ್ಯೂಲ್‌ಗಳು, ಕಾರ್ಯಗಳು, ಇತ್ಯಾದಿ) ವಿಸ್ತರಣೆಗೆ ತೆರೆದಿರಬೇಕು ಆದರೆ ಮಾರ್ಪಾಡುಗಾಗಿ ಮುಚ್ಚಲ್ಪಡಬೇಕು ಎಂದು ಹೇಳುತ್ತದೆ.

ಇದನ್ನು ಪಿಜ್ಜಾಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಟಾಪಿಂಗ್‌ಗಳನ್ನು ಸೇರಿಸುವಂತೆ ಯೋಚಿಸಿ. ಬೇಸ್ ಪಿಜ್ಜಾ (ಮೂಲ ಮಾಡ್ಯೂಲ್) ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಆದರೆ ನೀವು ಅದನ್ನು ಹೆಚ್ಚುವರಿ ಸುವಾಸನೆಗಳು ಮತ್ತು ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ (ಡೆಕೋರೇಟರ್‌ನ ಸೇರ್ಪಡೆಗಳು) ಹೆಚ್ಚಿಸಿದ್ದೀರಿ.

ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು

• ಸುಧಾರಿತ ಕೋಡ್ ಮರುಬಳಕೆ: ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಹು ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಬಹುದು, ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ವರ್ತನೆಯ ವರ್ಧನೆಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ವರ್ಧಿತ ನಿರ್ವಹಣೆ: ಕಾಳಜಿಗಳನ್ನು ಬೇರ್ಪಡಿಸುವ ಮೂಲಕ, ಡೆಕೋರೇಟರ್‌ಗಳು ಪ್ರತ್ಯೇಕ ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ವರ್ಧನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
• ಹೆಚ್ಚಿದ ನಮ್ಯತೆ: ಮೂಲ ಮಾಡ್ಯೂಲ್‌ನ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸದೆ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಲು ಅಥವಾ ಮಾರ್ಪಡಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ.
• ಓಪನ್/ಕ್ಲೋಸ್ಡ್ ತತ್ವದ ಅನುಸರಣೆ: ಡೆಕೋರೇಟರ್‌ಗಳು ಮೂಲ ಕೋಡ್ ಅನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸದೆ ಮಾಡ್ಯೂಲ್‌ಗಳ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ ಮತ್ತು ದೋಷಗಳನ್ನು ಪರಿಚಯಿಸುವ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಸುಧಾರಿತ ಪರೀಕ್ಷಾ ಸಾಮರ್ಥ್ಯ: ಡೆಕೋರೇಟರ್ ಕಾರ್ಯಗಳನ್ನು ಅಣಕಿಸುವ ಅಥವಾ ಸ್ಟಬ್ಬಿಂಗ್ ಮಾಡುವ ಮೂಲಕ ಅಲಂಕರಿಸಲ್ಪಟ್ಟ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ಪರೀಕ್ಷಿಸಬಹುದು.

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಅನುಷ್ಠಾನ

ಇದರ ಹೃದಯಭಾಗದಲ್ಲಿ, ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್ ಉನ್ನತ-ಕ್ರಮದ ಕಾರ್ಯವಾಗಿದೆ. ಇದು ಒಂದು ಕಾರ್ಯವನ್ನು (ಅಥವಾ ವರ್ಗ) ವಾದವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಹೊಸ, ಮಾರ್ಪಡಿಸಿದ ಕಾರ್ಯವನ್ನು (ಅಥವಾ ವರ್ಗ) ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮೂಲ ಕಾರ್ಯವನ್ನು ಹೇಗೆ ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಅಪೇಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ಸೇರಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಮೂಲ ಡೆಕೋರೇಟರ್ ಉದಾಹರಣೆ (ಫಂಕ್ಷನ್ ಡೆಕೋರೇಟರ್)

ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಲಾಗ್ ಮಾಡಲು ಕಾರ್ಯವನ್ನು ಅಲಂಕರಿಸುವ ಸರಳ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ:

            function timingDecorator(func) {
  return function(...args) {
    const start = performance.now();
    const result = func.apply(this, args);
    const end = performance.now();
    console.log(`Function ${func.name} took ${end - start}ms`);
    return result;
  };
}

function myExpensiveFunction(n) {
  let result = 0;
  for (let i = 0; i < n; i++) {
    result += i;
  }
  return result;
}

const decoratedFunction = timingDecorator(myExpensiveFunction);

console.log(decoratedFunction(100000));

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, timingDecorator ಡೆಕೋರೇಟರ್ ಕಾರ್ಯವಾಗಿದೆ. ಇದು myExpensiveFunction ಅನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಮೂಲ ಕಾರ್ಯವನ್ನು ಸುತ್ತುವ ಹೊಸ ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಹೊಸ ಕಾರ್ಯವು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಅಳೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ.

ವರ್ಗ ಡೆಕೋರೇಟರ್‌ಗಳು (ES ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪ)

ECMAScript ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪ (ಪ್ರಸ್ತುತ ಹಂತ 3 ರಲ್ಲಿ) ತರಗತಿಗಳು ಮತ್ತು ವರ್ಗ ಸದಸ್ಯರನ್ನು ಅಲಂಕರಿಸಲು ಹೆಚ್ಚು ಸೊಗಸಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಎಲ್ಲಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರಗಳಲ್ಲಿ ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರಮಾಣೀಕರಿಸದಿದ್ದರೂ, ಇದು ಆಕರ್ಷಣೆಯನ್ನು ಗಳಿಸುತ್ತಿದೆ ಮತ್ತು ಬ್ಯಾಬೆಲ್ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಪರಿಕರಗಳಿಂದ ಬೆಂಬಲಿತವಾಗಿದೆ.

ವರ್ಗ ಡೆಕೋರೇಟರ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            // Requires a transpiler like Babel with the decorators plugin

function LogClass(constructor) {
  return class extends constructor {
    constructor(...args) {
      super(...args);
      console.log(`Creating a new instance of ${constructor.name}`);
    }
  };
}

@LogClass
class MyClass {
  constructor(name) {
    this.name = name;
  }
  greet() {
    console.log(`Hello, ${this.name}!`);
  }
}

const instance = new MyClass("Alice");
instance.greet();

            

              
                Copy
              
            
          

ಈ ಸಂದರ್ಭದಲ್ಲಿ, @LogClass ಒಂದು ಡೆಕೋರೇಟರ್ ಆಗಿದ್ದು, ಅದನ್ನು MyClass ಗೆ ಅನ್ವಯಿಸಿದಾಗ, ವರ್ಗದ ಹೊಸ ನಿದರ್ಶನವನ್ನು ರಚಿಸಿದಾಗಲೆಲ್ಲಾ ಸಂದೇಶವನ್ನು ಲಾಗ್ ಮಾಡಲು ಅದರ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

ವಿಧಾನ ಡೆಕೋರೇಟರ್‌ಗಳು (ES ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪ)

ನೀವು ತರಗತಿಯೊಳಗಿನ ಪ್ರತ್ಯೇಕ ವಿಧಾನಗಳನ್ನು ಸಹ ಅಲಂಕರಿಸಬಹುದು:

            // Requires a transpiler like Babel with the decorators plugin

function LogMethod(target, propertyKey, descriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function(...args) {
    console.log(`Calling method ${propertyKey} with arguments: ${args}`);
    const result = originalMethod.apply(this, args);
    console.log(`Method ${propertyKey} returned: ${result}`);
    return result;
  };
  return descriptor;
}

class MyClass {
  constructor(name) {
    this.name = name;
  }

  @LogMethod
  add(a, b) {
    return a + b;
  }
}

const instance = new MyClass("Bob");
instance.add(5, 3);

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, @LogMethod add ವಿಧಾನವನ್ನು ಅಲಂಕರಿಸುತ್ತದೆ, ವಿಧಾನಕ್ಕೆ ರವಾನೆಯಾದ ವಾದಗಳನ್ನು ಮತ್ತು ಅದು ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ.

ಸಾಮಾನ್ಯ ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್ ಮಾದರಿಗಳು

ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ವಿವಿಧ ವಿನ್ಯಾಸ ಮಾದರಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಕ್ರಾಸ್-ಕಟಿಂಗ್ ಕಾಳಜಿಗಳನ್ನು ಸೇರಿಸಲು ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಕೆಲವು ಸಾಮಾನ್ಯ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

1. ಲಾಗಿಂಗ್ ಡೆಕೋರೇಟರ್

ಹಿಂದಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ, ಲಾಗಿಂಗ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಲಾಗಿಂಗ್ ಕಾರ್ಯವನ್ನು ಸೇರಿಸುತ್ತವೆ, ಅವುಗಳ ನಡವಳಿಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಬಗ್ಗೆ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಇದು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ: ಲಾಗಿಂಗ್ ಡೆಕೋರೇಟರ್ ಕೇಂದ್ರ ಲಾಗಿಂಗ್ ಸೇವೆಗೆ ಕಾರ್ಯ ಕರೆಗಳು, ವಾದಗಳು, ಹಿಂತಿರುಗುವ ಮೌಲ್ಯಗಳು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಲಾಗ್ ಮಾಡಬಹುದು. ಬಹು ಸೇವೆಗಳಲ್ಲಿ ವಿನಂತಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ನಿರ್ಣಾಯಕವಾಗಿರುವ ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗಳು ಅಥವಾ ಮೈಕ್ರೋ ಸರ್ವೀಸಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಮೌಲ್ಯಯುತವಾಗಿದೆ.

2. ಸಂಗ್ರಹ ಡೆಕೋರೇಟರ್

ದುಬಾರಿ ಫಂಕ್ಷನ್ ಕರೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಸಂಗ್ರಹ ಡೆಕೋರೇಟರ್‌ಗಳು, ಒಂದೇ ಮೌಲ್ಯಗಳನ್ನು ಪದೇ ಪದೇ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತವೆ.

            function cacheDecorator(func) {
  const cache = new Map();

  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log("Fetching from cache");
      return cache.get(key);
    }

    const result = func.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

function expensiveCalculation(n) {
  console.log("Performing expensive calculation");
  // Simulate a time-consuming operation
  let result = 0;
  for (let i = 0; i < n; i++) {
    result += Math.sqrt(i);
  }
  return result;
}

const cachedCalculation = cacheDecorator(expensiveCalculation);

console.log(cachedCalculation(1000));
console.log(cachedCalculation(1000)); // Fetches from cache

            

              
                Copy
              
            
          

ಅಂತರರಾಷ್ಟ್ರೀಕರಣದ ಉದಾಹರಣೆ: ಕರೆನ್ಸಿ ವಿನಿಮಯ ದರಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಸಂಗ್ರಹ ಡೆಕೋರೇಟರ್ ಕರೆನ್ಸಿ ಪರಿವರ್ತನೆ ಸೇವೆಗೆ API ಕರೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು, ಮಾಡಿದ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಧಾನಗತಿಯ ಇಂಟರ್ನೆಟ್ ಸಂಪರ್ಕ ಹೊಂದಿರುವ ಬಳಕೆದಾರರಿಗೆ ಅಥವಾ ಹೆಚ್ಚಿನ ಸುಪ್ತತೆಯ ಪ್ರದೇಶಗಳಲ್ಲಿರುವವರಿಗೆ ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

3. ದೃಢೀಕರಣ ಡೆಕೋರೇಟರ್

ದೃಢೀಕರಣ ಡೆಕೋರೇಟರ್‌ಗಳು ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ಸ್ಥಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಕೆಲವು ಮಾಡ್ಯೂಲ್‌ಗಳು ಅಥವಾ ಕಾರ್ಯಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತವೆ. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸುರಕ್ಷಿತಗೊಳಿಸಲು ಮತ್ತು ಅನಧಿಕೃತ ಪ್ರವೇಶವನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

            function authenticationDecorator(func) {
  return function(...args) {
    if (isAuthenticated()) { // Replace with your authentication logic
      return func.apply(this, args);
    } else {
      console.log("Authentication required");
      return null; // Or throw an error
    }
  };
}

function isAuthenticated() {
  // Replace with your actual authentication check
  return true; // For demonstration purposes
}

function sensitiveOperation() {
  console.log("Performing sensitive operation");
}

const authenticatedOperation = authenticationDecorator(sensitiveOperation);

authenticatedOperation();

            

              
                Copy
              
            
          

ಜಾಗತಿಕ ಸನ್ನಿವೇಶ: ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ, ಅಧಿಕೃತ ಉದ್ಯೋಗಿಗಳಿಗೆ ಮಾತ್ರ ಆದೇಶ ನಿರ್ವಹಣೆ ಕಾರ್ಯಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸಲು ದೃಢೀಕರಣ ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು. isAuthenticated() ಕಾರ್ಯವು ವೇದಿಕೆಯ ಭದ್ರತಾ ಮಾದರಿಯ ಆಧಾರದ ಮೇಲೆ ಬಳಕೆದಾರರ ಪಾತ್ರಗಳು ಮತ್ತು ಅನುಮತಿಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗುತ್ತದೆ, ಇದು ಪ್ರಾದೇಶಿಕ ನಿಯಮಗಳನ್ನು ಅವಲಂಬಿಸಿ ಬದಲಾಗಬಹುದು.

4. ಮೌಲ್ಯೀಕರಣ ಡೆಕೋರೇಟರ್

ಮೌಲ್ಯೀಕರಣ ಡೆಕೋರೇಟರ್‌ಗಳು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು ಕಾರ್ಯದ ಇನ್‌ಪುಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತವೆ, ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.

            function validationDecorator(validator) {
  return function(func) {
    return function(...args) {
      const validationResult = validator(args);
      if (validationResult.isValid) {
        return func.apply(this, args);
      } else {
        console.error("Validation failed:", validationResult.errorMessage);
        throw new Error(validationResult.errorMessage);
      }
    };
  };
}

function createUserValidator(args) {
  const [username, email] = args;
  if (!username) {
    return { isValid: false, errorMessage: "Username is required" };
  }
  if (!email.includes("@")) {
    return { isValid: false, errorMessage: "Invalid email format" };
  }
  return { isValid: true };
}

function createUser(username, email) {
  console.log(`Creating user with username: ${username} and email: ${email}`);
}

const validatedCreateUser = validationDecorator(createUserValidator)(createUser);

validatedCreateUser("john.doe", "john.doe@example.com");
validatedCreateUser("jane", "invalid-email");

            

              
                Copy
              
            
          

ಸ್ಥಳೀಕರಣ ಮತ್ತು ಮೌಲ್ಯೀಕರಣ: ಜಾಗತಿಕ ವಿಳಾಸ ನಮೂನೆಯಲ್ಲಿ ಬಳಕೆದಾರರ ದೇಶದ ಆಧಾರದ ಮೇಲೆ ಅಂಚೆ ಕೋಡ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಮೌಲ್ಯೀಕರಣ ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು. validator ಕಾರ್ಯವು ಬಾಹ್ಯ API ಅಥವಾ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನಿಂದ ಪಡೆದ ದೇಶ-ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯೀಕರಣ ನಿಯಮಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಪ್ರತಿ ಪ್ರದೇಶದ ಅಂಚೆ ಅಗತ್ಯತೆಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ವಿಳಾಸ ಡೇಟಾ ಸ್ಥಿರವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

5. ಮರುಪ್ರಯತ್ನ ಡೆಕೋರೇಟರ್

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವವನ್ನು ಸುಧಾರಿಸುವಲ್ಲಿ ವಿಫಲವಾದರೆ ಮರುಪ್ರಯತ್ನ ಡೆಕೋರೇಟರ್‌ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾರ್ಯ ಕರೆಯನ್ನು ಮರುಪ್ರಯತ್ನಿಸುತ್ತವೆ, ವಿಶೇಷವಾಗಿ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ಸೇವೆಗಳು ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ.

            function retryDecorator(maxRetries) {
  return function(func) {
    return async function(...args) {
      let retries = 0;
      while (retries < maxRetries) {
        try {
          const result = await func.apply(this, args);
          return result;
        } catch (error) {
          console.error(`Attempt ${retries + 1} failed:`, error);
          retries++;
          await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second before retrying
        }
      }
      throw new Error(`Function failed after ${maxRetries} retries`);
    };
  };
}

async function fetchData() {
  // Simulate a function that might fail
  if (Math.random() < 0.5) {
    throw new Error("Failed to fetch data");
  }
  return "Data fetched successfully!";
}

const retryFetchData = retryDecorator(3)(fetchData);

retryFetchData()
  .then(data => console.log(data))
  .catch(error => console.error("Final error:", error));

            

              
                Copy
              
            
          

ನೆಟ್‌ವರ್ಕ್ ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವ: ಅಸ್ಥಿರ ಇಂಟರ್ನೆಟ್ ಸಂಪರ್ಕ ಹೊಂದಿರುವ ಪ್ರದೇಶಗಳಲ್ಲಿ, ಆರ್ಡರ್‌ಗಳನ್ನು ಸಲ್ಲಿಸುವುದು ಅಥವಾ ಡೇಟಾವನ್ನು ಉಳಿಸುವುದು ಮುಂತಾದ ನಿರ್ಣಾಯಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಅಂತಿಮವಾಗಿ ಯಶಸ್ವಿಯಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮರುಪ್ರಯತ್ನ ಡೆಕೋರೇಟರ್ ಅಮೂಲ್ಯವಾಗಿದೆ. ಮರುಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಮರುಪ್ರಯತ್ನಗಳ ನಡುವಿನ ವಿಳಂಬವನ್ನು ನಿರ್ದಿಷ್ಟ ಪರಿಸರ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯ ಸೂಕ್ಷ್ಮತೆಯನ್ನು ಆಧರಿಸಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕು.

ಸುಧಾರಿತ ತಂತ್ರಗಳು

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

ಒಂದೇ ಮಾಡ್ಯೂಲ್‌ಗೆ ಬಹು ವರ್ಧನೆಗಳನ್ನು ಅನ್ವಯಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು. ಇದು ಮೂಲ ಮಾಡ್ಯೂಲ್‌ನ ಕೋಡ್ ಅನ್ನು ಮಾರ್ಪಡಿಸದೆ ಸಂಕೀರ್ಣ ಮತ್ತು ಹೆಚ್ಚು ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ ನಡವಳಿಕೆಯನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

            //Requires transpilation (Babel/Typescript)
function ReadOnly(target, name, descriptor) {
    descriptor.writable = false;
    return descriptor;
}

function Trace(target, name, descriptor) {
    const original = descriptor.value;
    descriptor.value = function (...args) {
        console.log(`TRACE: Calling ${name} with arguments: ${args}`);
        const result = original.apply(this, args);
        console.log(`TRACE: ${name} returned: ${result}`);
        return result;
    };
    return descriptor;
}

class Calculator {
    constructor(value) {
        this.value = value;
    }

    @Trace
    add(amount) {
        this.value += amount;
        return this.value;
    }

    @ReadOnly
    @Trace
    getValue() {
        return this.value;
    }
}

const calc = new Calculator(10);
calc.add(5); // Output will include TRACE messages
console.log(calc.getValue()); // Output will include TRACE messages

try{
    calc.getValue = function(){ return "hacked!"; }
} catch(e){
    console.log("Cannot overwrite ReadOnly property");
}

            

              
                Copy
              
            
          

ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಗಳು

ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿ ಎನ್ನುವುದು ಡೆಕೋರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಕಾರ್ಯವಾಗಿದೆ. ಇದು ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಪ್ಯಾರಾಮೀಟರೈಸ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳ ಆಧಾರದ ಮೇಲೆ ಅವುಗಳ ನಡವಳಿಕೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

            function retryDecoratorFactory(maxRetries, delay) {
  return function(func) {
    return async function(...args) {
      let retries = 0;
      while (retries < maxRetries) {
        try {
          const result = await func.apply(this, args);
          return result;
        } catch (error) {
          console.error(`Attempt ${retries + 1} failed:`, error);
          retries++;
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      }
      throw new Error(`Function failed after ${maxRetries} retries`);
    };
  };
}

// Use the factory to create a retry decorator with specific parameters
const retryFetchData = retryDecoratorFactory(5, 2000)(fetchData);

            

              
                Copy
              
            
          

ಪರಿಗಣನೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ES ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ನೀವು ES ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಸೆಮ್ಯಾಂಟಿಕ್ಸ್ ಅನ್ನು ನೀವೇ ಪರಿಚಿತರಾಗಿರಿ. ಇದು ಇನ್ನೂ ಪ್ರಸ್ತಾಪವಾಗಿದೆ ಮತ್ತು ಭವಿಷ್ಯದಲ್ಲಿ ಬದಲಾಗಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.
• ಟ್ರಾನ್ಸ್‌ಪೈಲರ್‌ಗಳನ್ನು ಬಳಸಿ: ನೀವು ES ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಬ್ರೌಸರ್-ಹೊಂದಾಣಿಕೆಯ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಬ್ಯಾಬೆಲ್ ಅಥವಾ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಟ್ರಾನ್ಸ್‌ಪೈಲರ್ ನಿಮಗೆ ಬೇಕಾಗುತ್ತದೆ.
• ಅತಿಯಾದ ಬಳಕೆಯನ್ನು ತಪ್ಪಿಸಿ: ಡೆಕೋರೇಟರ್‌ಗಳು ಪ್ರಬಲವಾಗಿದ್ದರೂ, ಅವುಗಳನ್ನು ಅತಿಯಾಗಿ ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ. ತುಂಬಾ ಡೆಕೋರೇಟರ್‌ಗಳು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ.
• ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಕೇಂದ್ರೀಕರಿಸಿಕೊಳ್ಳಿ: ಪ್ರತಿಯೊಂದು ಡೆಕೋರೇಟರ್ ಒಂದೇ, ಉತ್ತಮವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಉದ್ದೇಶವನ್ನು ಹೊಂದಿರಬೇಕು. ಇದು ಅವುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
• ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ: ಅವು ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆ ಮತ್ತು ಯಾವುದೇ ದೋಷಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
• ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ: ಅವುಗಳ ಉದ್ದೇಶ, ಬಳಕೆ ಮತ್ತು ಯಾವುದೇ ಸಂಭಾವ್ಯ ಅಡ್ಡಪರಿಣಾಮಗಳನ್ನು ವಿವರಿಸುವ ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಗಣಿಸಿ: ಡೆಕೋರೇಟರ್‌ಗಳು ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಸೇರಿಸಬಹುದು. ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ, ವಿಶೇಷವಾಗಿ ಆಗಾಗ್ಗೆ ಕರೆಯಲ್ಪಡುವ ಕಾರ್ಯಗಳನ್ನು ಅಲಂಕರಿಸುವಾಗ. ಸೂಕ್ತವಾದಲ್ಲೆಲ್ಲಾ ಸಂಗ್ರಹ ತಂತ್ರಗಳನ್ನು ಬಳಸಿ.

ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು

ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ವಿವಿಧ ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಅನ್ವಯಿಸಬಹುದು, ಅವುಗಳೆಂದರೆ:

• ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು: ಅನೇಕ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್, ರೂಟಿಂಗ್ ಮತ್ತು ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್‌ನಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಆಂಗುಲರ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಅವಲಂಬಿಸಿದೆ.
• API ಕ್ಲೈಂಟ್‌ಗಳು: API ಕ್ಲೈಂಟ್ ಕಾರ್ಯಗಳಿಗೆ ಲಾಗಿಂಗ್, ಸಂಗ್ರಹಣೆ ಮತ್ತು ದೃಢೀಕರಣವನ್ನು ಸೇರಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
• ಡೇಟಾ ಮೌಲ್ಯೀಕರಣ: ಡೇಟಾವನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ಉಳಿಸುವ ಮೊದಲು ಅಥವಾ API ಗೆ ಕಳುಹಿಸುವ ಮೊದಲು ಅದನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
• ಈವೆಂಟ್ ನಿರ್ವಹಣೆ: ಈವೆಂಟ್ ನಿರ್ವಹಣೆ ತರ್ಕವನ್ನು ಸರಳಗೊಳಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ಡೆಕೋರೇಟರ್ ಮಾದರಿಗಳು ನಿಮ್ಮ ಕೋಡ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಪ್ರಬಲ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ, ಮರುಬಳಕೆ, ನಿರ್ವಹಣೆ ಮತ್ತು ಪರೀಕ್ಷಾ ಸಾಮರ್ಥ್ಯವನ್ನು ಉತ್ತೇಜಿಸುತ್ತವೆ. ಈ ಲೇಖನದಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಮಾದರಿಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ, ನೀವು ಸ್ವಚ್ಛವಾದ, ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು. ES ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾಪವು ವ್ಯಾಪಕವಾದ ದತ್ತು ಪಡೆಯುವುದರೊಂದಿಗೆ, ಈ ತಂತ್ರವು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಇನ್ನಷ್ಟು ಪ್ರಚಲಿತವಾಗುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಕೊಂಡೊಯ್ಯಲು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ನಿಮ್ಮ ಸ್ವಂತ ಕಸ್ಟಮ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ರಚಿಸಲು ಅನ್ವೇಷಿಸಿ, ಪ್ರಯೋಗಿಸಿ ಮತ್ತು ಸಂಯೋಜಿಸಿ.